import { ipcMain } from 'electron';
import { RegulationService } from './regulationService';

export class RegulationIpcService {
  static registerHandlers() {
    /**
     * 加载规范文件列表
     * @param event IPC事件对象
     * @param type 规范文件类型
     * @returns 规范文件列表或错误信息
     */
    ipcMain.handle('load-regulations', async (event, { type }) => {
      try {
        const regulations = await RegulationService.loadRegulationsByType(type);
        return { success: true, data: regulations };
      } catch (error) {
        return this.createErrorResponse(error, `加载${type}列表失败`);
      }
    });
    
    /**
     * 添加规范文件
     * @param event IPC事件对象
     * @param type 规范文件类型
     * @param fileName 文件名
     * @param fileData 文件数据
     * @returns 操作结果
     */
    ipcMain.handle('add-regulation', async (event, { type, fileName, fileData }) => {
      try {
        await RegulationService.addRegulationByType(type, fileName, fileData);
        return { success: true };
      } catch (error) {
        return this.createErrorResponse(error, `添加${type}失败`);
      }
    });
    
    /**
     * 删除规范文件
     * @param event IPC事件对象
     * @param type 规范文件类型
     * @param fileName 文件名
     * @returns 操作结果
     */
    ipcMain.handle('delete-regulation', async (event, { type, fileName }) => {
      try {
        await RegulationService.deleteRegulationByType(type, fileName);
        return { success: true };
      } catch (error) {
        return this.createErrorResponse(error, `删除${type}失败`);
      }
    });
    
    /**
     * 打开规范文件
     * @param event IPC事件对象
     * @param type 规范文件类型
     * @param fileName 文件名
     * @returns 操作结果
     */
    ipcMain.handle('open-regulation', async (event, { type, fileName }) => {
      try {
        await RegulationService.openRegulationByType(type, fileName);
        return { success: true };
      } catch (error) {
        return this.createErrorResponse(error, `打开${type}失败`);
      }
    });
    
    /**
     * 保存规范文件到用户选择的位置
     * @param event IPC事件对象
     * @param type 规范文件类型
     * @param fileName 文件名
     * @returns 保存路径或错误信息
     */
    ipcMain.handle('save-regulation', async (event, { type, fileName }) => {
      try {
        const filePath = await RegulationService.saveRegulationToUserLocationByType(type, fileName);
        return { success: true, filePath };
      } catch (error) {
        return this.createErrorResponse(error, `保存${type}失败`);
      }
    });

    /**
     * 扫描文件夹获取文件列表（递归）
     * 扫描指定文件夹及其子文件夹中的所有文件
     * @param event IPC事件对象
     * @param folderPath 文件夹路径
     * @param includeSubfolders 是否包含子文件夹
     * @param extensions 文件扩展名过滤（可选）
     * @returns 文件列表或错误信息
     */
    ipcMain.handle('scan-folder-files', async (event, { folderPath, includeSubfolders = true, extensions = [] }) => {
      try {
        const path = require('path');
        const fs = require('fs').promises;
        
        // 检查文件夹是否存在
        const stats = await fs.stat(folderPath);
        if (!stats.isDirectory()) {
          return this.createErrorResponse(new Error('指定路径不是文件夹'), '扫描文件夹失败');
        }

        const files: string[] = [];
        
        /**
         * 递归扫描文件夹
         */
        async function scanDirectory(dirPath: string) {
          const entries = await fs.readdir(dirPath, { withFileTypes: true });
          
          for (const entry of entries) {
            const fullPath = path.join(dirPath, entry.name);
            
            if (entry.isDirectory() && includeSubfolders) {
              // 递归扫描子文件夹
              await scanDirectory(fullPath);
            } else if (entry.isFile()) {
              // 检查文件扩展名过滤
              if (extensions.length === 0 || extensions.some((ext: string) => entry.name.toLowerCase().endsWith(ext.toLowerCase()))) {
                files.push(fullPath);
              }
            }
          }
        }
        
        // 开始扫描
        await scanDirectory(folderPath);
        
        return { 
          success: true, 
          data: { 
            files,
            totalCount: files.length,
            folderPath
          } 
        };
      } catch (error) {
        return this.createErrorResponse(error, '扫描文件夹失败');
      }
    });
  }

  /**
   * 统一错误响应格式
   * @param error 错误对象
   * @param defaultMessage 默认错误消息
   * @returns 标准化的错误响应对象
   */
  private static createErrorResponse(error: any, defaultMessage: string): { success: false; error: string } {
    const errorMessage = error instanceof Error ? error.message : String(error || defaultMessage);
    console.error(defaultMessage, error);
    return { success: false, error: errorMessage };
  }
}